파이썬 클린코드 | 6장 디스크립터로 멋진 객체 만들기

디스크립터 개요

디스크립터 메커니즘

• __get__

• __set__

• __delete__

• __set_name__

>>> class Attribute:
...    value = 42
...
>>> class Client:
...   attribute = Attribute()
...
>>> Client().attribute
<__main__.Attribute object at 0x7..>
>>> Client().attribute.value
42

class DescriptorClass:
	def __get__(self, instance, owner):
		if instance is None:
			return self
		logger.info(
			"%s.__get__ 메서드 호출(%r, %r)",
			self.__class__.__name__,
			instance,
			owner
		)
		return instance

class ClientClass:
	descriptor = DescriptorClass()

>>> client = ClientClass()
>>> client.descriptor
INFO: DescriptorClass.__get__ 메서드 호출
(<ClientClass object at ...>), <class 'ClientClass'>)
<ClientClass object at ...>
>>> client.descriptor is client
INFO: DescriptorClass.__get__ 메서드 호출
(<ClientClass object at ...>), <class 'ClientClass'>)
True

디스크립터 프로토콜의 메서드 탐색

get 메서드

__get__(self, instance, owner)
# owner = instance.__class__

class DescriptorClass:
	def __get__(self, instance, owner):
		if instance is None: # 클래스에서 호출된 경우
			return f"{self.__class__.__name__}.{owner.__name__}"
		return f"{instance} 인스턴스" # 인스턴스에서 호출된 경우

class ClientClass:
	descriptor = DescriptorClass()

>>> ClientClass.descriptor
'DescriptorClass.ClientClass'

>>> ClientClass().descriptor
'<descriptors_methods_1.ClientClass object at 0x...> 인스턴스' 

set 메서드

__set__(self, instance, value)

client.descriptor = "value"

class Validator:

	def __init__(
		self, validation_function: Callable[[Any], bool, error_msg: str]
	) -> None:
		self.validation_function = validation_function
		self.error_msg = error_msg

	def __call__(self, value):
		if not self.validation_function(value):
			raise ValueError(f"{value!r} {self.error_msg}")

class Field:

	def __init__(self, *validations):
		self._name = None
		self.validations = validations

	def __set_name__(self, owner, name):
		self._name = name

	def __get__(self, instance, owner):
		if instance is None:
			return self
		return instance.__dict__[self._name]

	def validate(self, value):
		for validation in self.validations:
			validation(value)

	def __set__(self, instance, value):
		self.validate(value)
		instance.__dict__[self._name] = value

class ClientClass:
	descriptor = Field(
		validation(lambda x: isintance(x, (int, float)), "는 숫자가 아님"),
		validation(lambda x: x >= 0, "는 0보다 작음"),
	)	

>>> client = ClientClass()
>>> client.descriptor = 42
>>> client.descriptor
42
>>> client.descriptor = -42
Traceback (most recent call last):
	...
ValueError: -42는 0보다 작음
>>>  client.descriptor = "invalid value"
	...
ValueError: 'invalid value'는 숫자가 아님

delete 메서드

__delete__(self, instance)

class ProtectedAttribute:

	def __init__(self, requires_role=None) -> None:
		self.permission_required = required_role
		self._name = None

	def __set_name__(self, owner, name):
		self._name = name

	def __set__(self, user, value):
		if value is None:
			raise ValueError(f"{self._name}를 None 으로 설정 할 수 없음")
		user.__dict__[self._name] = value

	def __delete__(self, user):
		if self.permission_required in user.permissions:
			user.__dict__[self._name] = None
		else:
			raise ValueError(
				f"{user!s} 사용자는 {self.permission_required} 권한이 없음"
			)

class User:
	"""admin 권한을 가진 사용자만 이메일 주소를 삭제할 수 있음"""
	
	email = ProtectedAttribute(required_role="admin")

	def __init__(
		self, username: str, email: str: str, permission_list: list = None
	) -> None:
		self.username = username
		self.email = email
		self.permissions = permission_list or []
	
	def __str__(self):
		return self.username

>>> admin = User("root", "root@d.com", ["admin"])
>>> user = User("user", "user1@d.com", ["email", "helpdesk"])
>>> admin.email
'root@d.com'
>>> del admin.email
>>> admin.email is None
True
>>> user.email
'user1@d.com'
>>> user.email = None
...
ValueError: email을 None 으로 설정 할 수 없음
>>> del user.email
...
ValueError: user 사용자는 admin 권한이 없음

set_name 메서드

__set_name__(self, owner, name)

class DescriptorWithName:

	def __init__(self, name=None):
		self.name = name

	def __set_name__(self, owner, name):
		self.name = name

디스크립터의 유형

비데이터 디스크립터

class NonDataDescriptor:

	def __init__(self, instance, owner):
		if instance in None:
			return self
		return 42

class ClientClass:
	descriptor = NonDataDescriptor()

>>> client = ClientClass()
>>> client.descriptor
42

>>> client.descriptor = 43
>>> client.descriptor
43

>>> del client.descriptor
>>> client.descriptor
42

>>> vars(client)
{}

>>> client.descriptor = 99
>>> vars(client)
{'descriptor': 99}

>>> del client.descriptor
>>> vars(client)
{}
>>> client.descriptor
42

데이터 디스크립터

class DataDescriptor:

	def __get__(self, instance, owner):
		if instance is None:
			return self
		return 42

	def __set__(self, instace, value):
		logger.debug("%s.descriptor를 %s 값으로 설정", instance, value)
		instance.__dict__["descriptor"] = value

class ClientClass:

	descriptor = DataDescriptor()

>>> client = ClientClass()
>>> client.descriptor
42

>>> client.descriptor = 99
>>> client.descriptor
42

>>> vars(client)
{'descriptor': 99}

>>> client.__dict__["descriptor"]
99

>>> del client.descriptor
Traceback (most recent call last):
...
AttributeError: __delete__

instance.__dict__["descriptor"] = value

setattr(instance, "descriptor", value)

디스크립터 실전

디스크립터를 사용한 애플리케이션

디스크립터를 사용하지 않은 예

class Traveller:
    def __init__(self, name, current_city):
        self.name = name
        self._current_city = current_city
        self._cities_visited = [current_city]

    @property
    def current_city(self):
        return self._current_city

    @current_city.setter
    def current_city(self, new_city):
        if new_city != self._current_city:
            self._cities_visited.append(new_city)
            self._current_city = new_city

    @property
    def cities_visited(self):
        return self._cities_visited

>>> googie = Traveller("googie", "seoul")
>>> googie.current_city = "paris"
>>> googie.current_city = "tokyo"
>>> googie.cities_visited
["seoul", "paris", "tokyo"]

이상적인 구현방법

class HistoryTracedAttribute:
    def __init__(self, trace_attribute_name) -> None:
        self.trace_attribute_name = trace_attribute_name
        self._name = None

    def __set_name__(self, owner, name):
        self._name = name

    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.__dict__[self._name]

    def __set__(self, instance, value):
        self._track_change_in_value_for_instance(instance, value)
        instance.__dict__[self._name] = value

    def _track_change_in_value_for_instance(self, instance, value):
        self._set_default(instance)
        if self._needs_to_track_change(instance, value):
            instance.__dict__[self.trace_attribute_name].append(value)

    def _needs_to_track_change(self, instance, value) -> bool:
        try:
            current_value = instance.__dict__[self._name]
        except KeyError:
            return True
        return value != current_value

    def _set_default(self, instance):
        instance.__dict__.setdefault(self.trace_attribute_name, [])

class Traveller:

    current_city = HistoryTracedAttribute("cities_visited")

    def __init__(self, name, current_city):
        self.name = name
        self.current_city = current_city

>>> googie = Traveller("googie", "seoul")

다른 형태의 디스크립터

전역 상태 공유 이슈

class SharedDataDescriptor:
    def __init__(self, initial_value):
        self.value = initial_value

    def __get__(self, instance, owner):
        if instance is None:
            return self
        return self.value

    def __set__(self, instance, value):
        self.value = value

class ClientClass:
    descriptor = SharedDataDescriptor("name is")

>>> googie = ClientClass()
>>> googie.descriptor
'name is'
>>> lena = ClientClass()
>>> lena.descriptor
'name is'
>>> lena.descriptor = "lena is"
>>> lena.descriptor
'lena is'
>>> googie.descriptor
'lena is'
# ClientClass.descriptor 가 고유하기 때문

객체의 사전에 접근하기

약한 참조 사용

from weakref import WeakKeyDictionary

class DescriptorClass:
    def __init__(self, initial_value):
        self.value = initial_value
        self.mapping = WeakKeyDictionary()

    def __get__(self, instance, owner):
        if instance is None:
            return self
        return self.mapping.get(instance, self.value)

    def __set__(self, instance, value):
        self.mapping[instance] = value

디스크립터에 대한 추가 고려사항

코드 재사용

클래스 데코레이터의 대안

@Serializaion(
    username=show_original,
    password=hide_field,
    ip=show_original,
    timestamp=format_time,
)
@dataclass
class LoginEvent:
    username: str
    password: str
    ip: str
    timestamp: datetime

from functools import partial
from typing import Callable

class BaseFieldTransformation:
    def __init__(self, trasformation: Callable[[], str]) -> None:
        self._name = None
        self.trasformation = transformation

    def __get__(self, instance, owner):
        if instance is None:
            return self
        raw_value = instance.__dict__[self._name]
        return self.transformation(raw_value)

    def __set_name__(self, owner, name):
        self._name = name

    def __set__(self, instance, value):
        instance.__dict__[self._name] = value

ShowOriginal = partial(BaseFieldTransformation, transformation=lambda x: x)
HideField = partial(
    BaseFieldTransformation, transformation=lambda x: "**민감한 정보 삭제**"
)
FormatTime = partial(
    BaseFieldTransformation, transformation=lambda ft: ft.strftime("%Y-%m-%d %H:%M")
)

class LoginEvent:
    username = ShowOriginal()
    poassword = HideField()
    ip = ShowOriginal()
    timestamp = FormatTime()

    def __init__(self, username, password, ip, timestamp):
        self.username = username
        self.password = password
        self.ip = ip
        self.timestamp = timestamp

    def serialize(self):
        return {
            "username": self.username,
            "password": self.password,
            "ip": self.ip,
            "timestamp": self.timestamp,
        }

class LoginEvent(BaseEvent):
    username = ShowOriginal()
    password = HideField()
    ip = ShowOriginal()
    timestamp = FormatTime()

디스크립터 분석

파이썬 내부에서의 디스크립터 활용

함수와 메서드

class MyClass:
    def method(self, ...):
        self.x = 1

class MyClass: pass

def method(myclass_instance, ...):
    myclass_instance.x = 1

method(MyClass())

메서드를 위한 빌트인 데코레이터

슬롯(slot)

데코레이터를 디스크립터로 구현하기

class LogCallsDecorator:
    def __init__(self, func):
        self.func = func

    def __get__(self, instance, owner):
        # 클래스를 가진 인스턴스의 메서드에 액세스할 때 호출됩니다.
        if instance is None:
            return self.func  # 클래스 자체에서 액세스하여 원래 기능을 반환합니다.
        
        # 원래 방법을 감싼 새 방법을 정의합니다.
        def wrapped_method(*args, **kwargs):
            print(f"Calling method '{self.func.__name__}'")
            result = self.func(instance, *args, **kwargs)
            print(f"Method '{self.func.__name__}' finished")
            return result

        return wrapped_method

class MyClass:
    def __init__(self, value):
        self.value = value

    @LogCallsDecorator
    def add(self, x, y):
        return x + y

obj = MyClass(10)
result = obj.add(5, 7)
# descriptor의 __get__ 메소드를 트리거
print("Result:", result)
# Result: 12